<possibleDataStructures>

	doubleArray = constant size array of java type double
	nodeArray = constant size 
	node = constant size sequence of doubleArray and/or nodeArray
		with network-defined requirements on the combinations of sizes of those arrays.
	network = dynamicly sorted list of nodes,
		and an immutable (and same for each node) definition of size requirements on arrays of each node,
		and an immutable algorithm to execute on each node which may change the order of nodes in this network,
		and maybe algorithms for adding or removing or merging or duplicating nodes as childs of other nodes.
	node* = multiply 2 arrays of node, which can be viewed as pairs of nodes to iterate over.
	node^ = array of node power other array of node, which can be viewed as pairs of nodes to iterate over.
	audivolvFunc = function which uses the same floating point array (of a specific size) as input and output.
	iterator = immutable algorithm in a network which iterates over any parts of 1 node.
		If it is standardized in the network, multiple iterators could run on each node, wrapped in 1 function.
	fpArray+ = concat 2 floating point sequences.
		Example: floating point array size 3
			concat 1 floating point from an array size 2^5 is size 4 in each iteration.
	
	In a network, the same iterator algorithm(s) must be for all nodes. If there are many,
	can complex if/else conditions change the order of iterators or choose if they run?
	
	In a network, should there be multiple dynamicly sorted lists of the same nodes?
	It could run different algorithms on on first node in each of the different lists.
	But that is complex so it would have to give me a valuable feature, which I can not think of now.
	
	Should size of a node list be able to depend on node^ of other node lists?
	Certainly node* for node lists is needed, and node^ is needed for floating point arrays.
	For completeness, since node* is needed, node^ should also be allowed.
	
	fpArray+ should be only for the floating points used in iterators, not any of the arrays in nodes.
	
	Size of all doubleArrays and nodeArrays should be defined by all 3 of these:
		int min,
		int max,
		recursive function including *, ^, and/or size of nodeArray(s) in this node or network.
	Size should not be allowed to depend on +.
	
	Should size of doubleArray be allowed to depend on size of other doubleArray (instead of nodeArray)?
	If not, it could be impractical to have a doubleArray size 3*(2^bayesChilds)		
	
	Network should contain some nodeArrays if their contents do not change between nodes.
	Example: [nodeSortValue]
	Example: [bayesFalse,bayesTrue]
	Example: [bayesChance,bayesChanceCertainty,bayesWantChanceCertainty]
	Similarly, network can also contain immutable doubleArrays.
	Other nodeArrays go in the nodes.
	Example: [...bayes childs...] may have size between 0 and 6
	Other doubleArrays go in the nodes.
	Example: [...bayes weights...] probably has size bayesTF^bayesChilds
	
	Because al algorithms are run from a network and not its nodes,
	it is not necessary for nodes to contain the floating points used for sorting those nodes.
	If its efficient, those floating points could instead be 1 doubleArray
	the same size as its nodeArray.
	
	Should all arrays have size which depends on at most 2 other arrays?
	For example, instead of:
		d = x*(y^z)
	Use these multiple sizes:
		c = y^z
		d = x*c
	Arrays can be shared in the network or individual to each node,
		so multiplying by a constant is made efficient by having that constant in the network.
	Similarly, int min and max can be represented without any literal ints by using arrays that size.
	For example, if a node can have at most 30000 childs,
		it is practical to keep 1 nodeArray size 30000 in the network which contains the same node 30000 times.
		If that was impractical, then 1 node having that many childs is also impractical.
	No int constants are allowed. Literal arrays are allowed.
	
	The size of an array is exactly specified by the sequence of 4 arrays.
	Some of those 4 arrays can be in the node therefore must tell where the array is but have no pointer.
	arraySizeRequirement[0] = nodeArray whose size equals my min size.
	arraySizeRequirement[1] = nodeArray whose size equals my max size.
	arraySizeRequirement[2] = nodeArray whose size is the first parameter of * or ^.
	arraySizeRequirement[3] = nodeArray whose size is the second parameter of * or ^.
	But that does not tell which of * or ^.
	
	How to define "where the array is but have no pointer"?
	As a string its easy. Example: "network[5]". Example: "node[2]".
	If I try to make it very small, I could organize the bits this way:
		1 bit - network or node
		7 bits - which index
	Sizes of other arrays can be much bigger. These are pointers to arrays, but maybe that should be the same.
		4*(1+7) can fit in an int.
	Need more things than that. List them:
		Target is in network or node?
		Target is in which index?
		Need only 1 of these per node, not per pointer: My size depends on which operator, * or ^ or possibly more later?
		Not relevant to size: Is this a nodeArray or doubleArray? Or instead, same question about what this points at.
	If 52 possible array locations (26 in node and 26 in network) are enough,
	then ASCII gives an easily readable way to write it.
	A-Z would be indexs in network, and a-z would be indexs in node. * and ^ are also ASCII chars.
	arraySizeRequirement[min=d,max=Z,op=*,lvalue=b,rvalue=g] could be written as: dZ*bg
		and that fits in 40 bits which is reliable to store in a double.
		It would take a lot of roundoff error to break that, but it would happen eventually.
		Storing ASCII as 7 bits per char would be 35, and that is much more reliable,
		but storing as 1 byte per char is simpler.
	
	A node may be defined as
		"dZ*bg,aX*jg,ZY^Fs", which means a="dZ*bg", b="aX*jg", c="ZY^Fs".
	That is much simpler than the syntax I was considering before which looked like
		"bayesTF=node[2],bayesChilds=node[1,9],tempVars=double[bayesTF*bayesChilds],bayesChances=double[bayesTF^bayesChilds]"
	
	But "dZ*bg,aX*jg,ZY^Fs" does not allow a literal array size 30000, which is sometimes needed.
	
	Another problem is that the literal arrays may have to contain
		specific important data, like [bayesFalse,bayesTrue],
		but that should be be described in this string.
		Should that be represented like this "2,30000,dZ*bg,aX*jg,25,ZY^Fs"?
		
	Should the first char be the type and second char be how to specify the size?
	---------------
	D double array
	n node array
	N network array
	f function array
	S short array //not all of them will be used...
	Z boolean array
	J long array
	---------------
	0 literal base-10 number
	* multiply: min max lvalue rvalue
	^ power: min max lvalue rvalue
	! factorial: min max lvalue //not all of them will be used...
	+ plus: min max lvalue rvalue
	---------------
	Example: "D030000" could be a floating point array size 30000.
	Example: "D*aXjg" could be a floating point array with min size a max size X and size j*g.
	Example: "n017" could be a node array size 17.
	I'm not sure which chars I should use to mean which types (float array, node array, etc).
	
	If "dZ*bg,aX*jg,ZY^Fs" is extended to have 51 commas and 52 things between commas,
		it could represent the whole network's size requirements.
		
	It does not tell which types the 52 arrays are, which may be limited to doubleArray and nodeArray of the same type of node.
	
	Would I ever want to use networkArray, nodeArray, and doubleArray in the same data structure?
	
	It also does not say how to copy a size exactly,
		but that can be simulated by multiplying by an array size 1.
		
	This design does not allow multiple types of nodes in the same net, but that is probably more complex than its worth, because multiple nets can have their nodes put side by side to simulate that.
	
	
	How would that handle using 2*12^3 with 2^12?
	2^12 easily pairs with 2*12, but that selects only 1 of the 12 at a time.
	What if I wanted to select 2 3 or 7 of the 12 at a time?
	Is fibonacci related here? Can fibonacci be another operator like * and ^?
	Do the simple array size definitions above (allowing only 1 operator with 2 parameters) allow that?
	
	
	How to specify which nodeArrays (in a node X) must contain X (always at index 0?)?
	For example, it would simplify the design of bayesian nodes if their childs include themself first.
	
	Maybe array sizes should not be written at all, in this small syntax. Just mark them as literals and let them be defined by their data. For example, instead of 'D030000', write 'D?' or some other char that means literal.
	Example of 4 comma separated sizes: "=M,*dZbg,*aXjg,^ZYFs". What types?
	Example of 4 types and sizes: "D;=M,L;*dZbg,L;*aXjg,D;^ZYFs". What types?
	
	Maybe its better to store them in 2 separate arrays?
	"=M,*dZbg,*aXjg,^ZYFs"
	"D,L,L,D"
	
	How to specify type and size of all 52 (or less) arrays, which defines network size limits, as string(s)?
	{"=M","*dZbg","*aXjg","^ZYFs"}
	Probably not a good syntax: "arraySizes( =(M) *(d Z b g) *(a X j g) ^(Z Y F s) )"
	
	Big problem: How to point at an array in a child node of a parent node?
	The syntax described above uses capital letters to refer to global things in the network
	and lowercase to refer to things in the current node,
	but things in child nodes must also be referred to.
	There may be no way to get around generalizing the target section as a char instead of a bit.
	But that is not needed here because size of array in a node can not depend on array in child node.
	Nodes must all have the same size requirements (but can be different sizes within those).
	
	Still, it would be more flexible to define certain location types as specific chars forever unchangable.
	For example, need chars for these:
		current network, current node, child node in array x, child node in array y, etc.
		
	How to define which floating points an evolved function will get as parameters?
	It must be able to take floating point(s) from child nodes multiple arrays.
	
	
	
	
	Why should the simple syntax include type of array (double, Object, etc)?
	Its an array size. Type should be separate, even if its written adjacent.
	
	There are very few chars on normal keyboards that dont have standardized meanings.
	These do not include math chars: plus+ minus- multiply* divide/ power^ remainder% equal= factorial!
	These maybe include: and& or|
	These do include: ~ ` @ # $ _ \ " ' : ; ? .
		Of those, all are common in programming.
	
	
	[START: The next text is copied from other file and I will modify it.]
	
	How should floats.size="node*(chanceAccuracyWant node^(bayesTruthConstants childNodes))"
	be combined with shorterFloatList.size="bayesTruthConstants * childNodes"?
	Confusing...
	"node*( childNodes node*(chanceAccuracyWant node^(bayesTruthConstants childNodes)) )"
	
	Lets simplify it and solve that problem later. Solve this first...
	"node*( childNodes node^(bayesTruthConstants childNodes) )"
	double d[] = new double[?];
	pow = (int) bayesTruthConstants power childNodes;
	for(nodeX in childNodes){
		for(p from 0 to pow-1){
			...todo write the pseudocode here...
		}
	}
	
	Lets try something easier. The problem is node lists can be used any number of times,
	and current thinking makes them all be used exactly once.
	It should be this form: codeTreeFrom --> codeTreeTo, where each part of codeTreeFrom points to some part of codeTreeTo, and all parts of codeTreeTo are pointed to at least once, but some parts of codeTreeFrom may not point to anything.
	
	Can it handle this one?:
	"node^(bayesTruthConstants1 childNodes1)" --> "node*(bayesTruthConstants0 childNodes0)"
	Maybe write it this way?:
	"node*( node*(bayesTruthConstants0 childNodes0) node^(bayesTruthConstants1 childNodes1) )"
	--> "node*(bayesTruthConstants0 childNodes0)"

	Example:
	"node*( node*(bayesTruthConstants0 childNodes0) node^(bayesTruthConstants1 childNodes1) )"
	--> "node*(bayesTruthConstants0 childNodes0)"
	But that does not specify that bayesTruthConstants does not increase the iteration size.
	For example, 2*5 * 2^5 has 5 * 2^5 iterations and 2*5 output size
	That could be written without the arrow -->, like this:
	"node*( node*(bayesTruthConstants_inonly childNodes_inandout) node^(bayesTruthConstants_inonly childNodes_inonly) )"
	
	Example: "node*(x node^(y x))" --> "node*(x y)"
	
	Theory: outputs sets and sizes <= inputs sets and sizes <= iterationSize
	
	Find counterexample where output sets contain anything that input sets do not.{
		If found, change:
		Theory: outputs sets and sizes <= inputs sets and sizes <= iterationSize
		
		Example: "neuralWeights" --> "1" //sums neural weights
		Fix example: "1 + neuralWeights" --> "1"
		
		If part of an output is not in the input, can it be trivially added?

	}

	Find example where input sets are smaller than iterationSize.{
		If that exists, use this theory instead:
		Theory: outputs sets and sizes <= inputs sets and sizes <= iterationSize

		If iterationSize is X times bigger than [inputs sets and sizes], multiply inputs by X.
	}
	
	[END: The next text is copied from other file and I will modify it.]
	
	The recursive functions written above for array size are too complex.
	By requiring an array (or Integer constant?) be created at each recursion,
	such complexity is avoided without losing any flexibility.
	
	The syntax I define here does not have to be permanent. I just need a simple syntax
	to get things started, and it can EASILY be changed later, or use multiple syntaxs.
	
	There are at least 3 syntaxs:
		netDefineSyntax,
		funcParamFinderSyntax,
		floatingPointArrayFuncSyntax.
		
	
	//Purpose of netDefineSyntax is define the standards of which arrays
	//go in a network and which in a node, their sizes and size constraint relationships,\
	//and which are Object arrays and which are double arrays.
	[netDefineSyntax]
		Type: double array, Object array.
		ArraySize: literal, equal, multiply*, power^.
		Location:
			??? index m in network,
			??? index i in node,
			??? array b in child list x, array y in child list g, etc,
			??? how to handle multiple nodes from a power^ array?

	//Purpose of funcParamFinderSyntax is, in the same way for each iteration over the things in a node,
	//to choose floating point(s) from some of the floating point arrays and concat them into
	//a floating point array of the right size, run a function on that array, and copy the resulting
	//floating points (written in the same array at same indexs)
	//individually back to their original locations.
	[funcParamFinderSyntax]
		Concat subsets of many locations, which must all be double arrays (no Object arrays):
			?get what from? network,
			?get what from? node,
			?get what from? array b in child list x,
			?get what from? array y in child list g,
			?get what from? etc,
			?get what from? how to handle multiple nodes from a power^ array?
			
	//Purpose of floatingPointArrayFuncSyntax is to statelessly
	//change the floating points in a small array.
	[floatingPointArrayFuncSyntax]
		May be similar to codesimian syntax, but not as complex as codesimian objects.
		The simplest thing would be to use a temporary floating point array
		and view the concat of it and the parameter array.
		Probably loops should not be allowed,
		because they make network cycles too hard to predict the duration of.
		This is a possible syntax, where multiple lines are used, and a-z are array indexs 0-25.
		+ a a b //a += b
		square f a //f = a*a
		
		
		
	
	Operators written in floatingPointArrayFuncSyntax...
	Most can exceed floating point range. Some have other dangers like divide by 0...
	Operators have at least 1 parameter (a, b, c...).
	They output 1 parameter, which is not written here,
	and that can equal one of the existing parameters or not, like a = a + b, or a = b + c.
	Operators include:
		Continuous math operators:
			+ a b
				Java translation: "+ a b c" --> "a=b+c;"
			- a b
			* a b
			/ a b
			% a b
			power a b
			log a b
			powere a
			loge a
			powertwo a
			logtwo a
			square a
			sqrt a
			sine a
			arcsine a
				Java translation: "arcsine a b" --> "a=Math.asin(b);"
			cosine a
			arccosine a
			tangent a
			arctangent a
			absval a
		Logic and discrete operators:
			min a b
			max a b
			floor a
			ceil a
			round a
			= a
			== a b
			< a b //returns 1 if a<b, else returns 0
			<= a b
			and a b //returns 1 if a and b are positive, else returns 0
			or a b
			xor a b
			not a
			+one a
			-one a
			=zero
			
	Need control-flow operators and a tree or network shape of code for good evolution.
	Maybe a "floatingPointArrayFuncSyntax" function
	should be able to call other floatingPointArrayFuncSyntax functions.
	
	Should a function be a network or node? That would give it recursion ability,
	and it would be easier to interface it to networks and nodes (but I dont know if I need that).
	I do need some type of function that merges 2 nodes in a network,
	but that maybe should be a different type of thing.
	
	Codesimian code may be close to what I need.

</possibleDataStructures>